\section{Les fonctions de la bibliothèque}
Toutes les structures de données définies plus haut ont servi à l'implémentation de fonctions principales de notre bibliothèque qui sont les suivantes:\footnote{Pour un détail sur les prototypes se réferer au fichier \texttt{thread.h}, nous donnons juste les principes des fonctions} 

\subsection{Fonction \texttt{thread\_self}}
Cette fonction retourne l'identifiant du thread courant. Le thread qui s'exécute est stocké dans une variable globale et donc à chaque appel de \texttt{thread\_self} on retourne l'identifiant du thread référencé par la variable globale.

\subsection{Fonction \texttt{thread\_create}}
Cette fonction permet de créer un thread. Comme défini plus haut, un thread est représenté par une structure et dans celle-ci se trouve un context qui correspond à un ensemble d'instructions que le thread exécute. A chaque appel de la fonction \texttt{thread\_create}, le context du thread appelant est sauvegardé et remplacer par le contexte du thread créé. Ainsi un thread créé est automatiquement lancé et le thread appelant est mis en file d'attente. 

\subsection{Fonction \texttt{thread\_yield}}
À l'appel de cette fonction, le thread appelant entend rendre la main. Lorsqu'un thread est lancé, on garde dans le thread l'information sur le contexte dans lequel il a été lancé donc \texttt{thread\_yield} sauvegarde dans le thread appelant son contexte et lance le contexte dans lequel celui-ci a été précédemment lancé.

\subsection{Fonction \texttt{thread\_exit}}
À l'appel de cette fonction, le thread appelant est sensé avoir fini son exécution et cherche donc à stocker sa valeur de retour. La fonction \texttt{thread\_exit} se contente de stocker dans la structure du thread appelant sa valeur de retour, de signaler que le thread a terminé en mettant son statut à STATUS\_FINISH et de lancer le contexte qui a précédé le sien.

\subsection{Fonction \texttt{thread\_join}}
Cette fonction est utilisée pour attendre la terminaison d'un thread. À l'appel de cette fonction, le thread appelant est stoppé jusqu'à ce que le thread qu'il a décidé d'attendre termine. Ainsi sa valeur de retour est récupérée et stockée dans une variable passée en paramètre.    

\subsection*{Commentaire}
Il apparait clairement que les fonctions \texttt{thread\_exit} et \texttt{thread\_join} doivent être liées. En effet, un thread est sensé avoir terminé qu'après un appel (et un seul est possible) de la fonction \texttt{thread\_exit}. Un appel \texttt{thread\_join} n'est possible que sur les seuls thread qui font un appel \texttt{thread\_exit} pendant leurs exécutions. Cependant l'ordre est sans importance: si on décide de faire un appel \texttt{thread\_join} pour attendre un thread qui a déjà fait un \texttt{thread\_exit} alors on récupère juste sa valeur de retour sinon on reste dans la fonction \texttt{thread\_join} jusqu'à ce que le thread attendu face un \texttt{thread\_exit} pour terminer. On comprend donc par là que c'est dans la fonction \texttt{thread\_join} que la politique d'ordonnancement est mis en oeuvre pendant l'attente d'un thread et c'est elle qui libère les ressources utilisées par les threads qui ont terminé. 
